typedef struct{
         	char  cristian;
	       	}Tinfo;   /* Reservado, NO USAR Tinfo como Tipo De Dato */ 

typedef struct s_nodo	/* Reservado, NO USAR struct s_nodo como Tipo De Dato */
	{
		int clave;
		struct s_nodo *next; 
		Tinfo info;
	}Tnodo; 	/* Reservado, No usar Tnodo como Tipo De Dato */



/* ============================================================================ */
/* =========================== INTRODUCCION =================================== */
/* ============================================================================ */
/* Las siguientes son un conjunto de funciones para el manejo Seguro y de pilas, 
 * Colas y Listas Ordenadas , sin tener que preocuparse por el manejo de Memoria, 
 * pudiendo realizar acciones como buscar, push, pop en pilas y colas,insertar
 * ordenado en Listas  y el cambio de estructura (pila-> cola, cola-> lista, etc) 
 * en tiempo de ejecucion.
 *
 * REESTRICCION= 
 *  	         En nuestro Capo Tinfo, no pueden utilizarse variables puntero
 * 		 en las cuales para su uso sea necesario PETICIONES DE MEMORIA.
 * 		 POR EJEMPLO= 
 * 		    	NO SE PUEDE USAR= char* cadena; si cadena apuntara a un
 * 		    	                  lugar NO existente previamente.
 * 		    	                  USAR= char cadena[50];
 * 		    	                  
 * 		    	
 * 		    	SI SE PUEDE USAR= char* cadena; si cadena apuntara a un
 * 		    	                  lugar Si existente previamente.
 * 
 * OBSERVACION=
 * 		Para Cada uso Particular HAY QUE REALIZAR UNA FUNCION cargarNodo(),
 * 		que tome como argumentos cada uno de los campos de Nuestra estructura
 * 		info y los cargue. Y QUE ADEMAS COPIE EN EL CAMPO clave del nodo
 * 		(EN FORMA DE CADENA DE CARACTERES) aquel campo que deseamos utilizar 
 * 		como clave, para el uso de listas ordenadas.
 * 
 * USO=		
 * 	TnodoNuestro* <NombreParaLaEstructura>;     	//Declaracion De Nuestra Estructura.
 * 	TnodoNuestro* unNodo;                       	//Declaracion De un Nodo gral.
 * 	
 * 	crear((Tnodo**)&<NombreParaLaEstructura>);   	//Inicializamos (pila cola o lista)
 * 		
 * 	crearNodo((Tnodo**)&unNodo,sizeof(TnodoNuestro));
 * 	cargarNodo(&unNodo,campo1,campo2,..,campoN);  	//Este Es Nuestro
 * 		
 * 	pushEnPila((Tnodo**)&NombreParaLaEstructura,(Tnodo**)&unNodo); 
 * 	| pushEnCola() |insertarElLista();
 * 	
 * 	popEnPila((Tnodo**)&NombreParaLaEstructura,(Tnodo**)&unnodo);  
 * 	| popEnCola()  | buscarNodo();
 * 	
 * 	"Usar los Datos"...... luego free(&unNodo);
 * 	
 * 	REPETIR
 * 	Finalmente LiberarEstructura(&<nombreParaLaEstructura>);
 * 	
 * 	OTROS=
 * 	colaToLista() | pilaTocola() | colaToPila() | colaToLista()
 */	


/* ============================================================================ */
/* ===================== CONJUNTO DE VALORES ================================== */
/* ============================================================================ */
/* Debemos realizar 2 estructuras, por cada (pila cola o lista) simultanea
 * que querramos usar, el INFO y en NODO...
 * POR EJEMPLO=

typedef struct{					
         	char nombre[30];		EDITAR
		int edad;			EDITAR
		double dni;			EDITAR
		char fechaDeNacimiento[15];	EDITAR
		int etc;			EDITAR
	       	}TNuestroINFO; 			EDITAR

typedef struct siguiente_nodo			EDITAR
	{
		char clave[30];			NO MODIFICAR
		struct siguiente_nodo *next;	SOLO EDITAR EL TIPO DE DATO
		TNuestroINFO info;		SOLO EDITAR EL TIPO DE DATO
	}TNuestroNodo;				EDITAR
*/



/* ============================================================================ */
/* ===================== CONJUNTO DE OPERACIONES ============================== */
/* ============================================================================ 
	 * 
	 * CAST= 	Todas las funciones esperan Tnodo**,
	 * 	 	por los tanto hay que realizar un cast para Nuestro nodo
	 * 
	 * RETORNO=	OK----> Retorna 1
	 * 		ERROR-> Retorna 0
	 
*/


/* ====================== OPERACIONES COMUNES ======================== */



/*-------------- Inicializar Una Pila Cola o Lista ------*/
int inicializar(Tnodo**);




/*---------------- Crear Nodo ------------------------------*/
int crearNodo(Tnodo** nodo,int tamanioNodo);





/*---------------- Cargar Nodo ------------------------------*
 * Debe Realizarse para nuestro Caso particular              *
 * EJ= int cargarNodo(TNuestroNodo** nodo,campo1,campo2,..);*
 * NOTA= En El Campo Clave Se debe copiar en forma de cadena *
 *       el nombre o el numero(como cadena de caracteres) 
 *       que querramos usar de Clave
 */



/*----------------- Eliminar Nodo --------------------------*/
int eliminarNodo(Tnodo** lista,Tnodo** nodo);			/*
	NOTA= Impresindible en el manejo de Listas
	      pero sirve tambien para colas y pilas		*/




/*--------------- Buscar Nodo ------------------------------*/

int buscarNodo(Tnodo** lista, int clave ,Tnodo** encontrado); /*
      NOTA= Impresindible en el manejo de listas          
            pero sirve tambien para colas y pilas	         */








/*------------ Liberar/Borrar/Deshacer ---------------------*/
int destruir(Tnodo **);



/* =================== OPERACIONES CON PILAS ============================ */



/*----------------- Push En Pila ---------------------------*/
int pushEnPila(Tnodo**pila,Tnodo** nodo);

/*----------------- Pop en Pila ----------------------------*/
int popEnPila(Tnodo**pila,Tnodo**nodo); /*Requiere free()*/

/*---------- Transformar Una Pila a Una Cola ---------------*/
int pilaToCola(Tnodo**pila);

/*------ Transformar Una Pila a Una Lista Ordenada ---------*/
int pilaToLista(Tnodo**pila);

/*------ Transformar Una Pila a Una Lista Ordenada Decreciente---------*/
int pilaToListaDec(Tnodo**pila);







/* ======================= OPERACIONES CON COLAS ========================= */




/*------------------ Push en cola --------------------------*/
int pushEnCola(Tnodo**cola,Tnodo**nodo);

/*------------------ Pop en Cola ---------------------------*/
int popEnCola(Tnodo**cola,Tnodo**nodo); /*Requiere free()*/

/*-------------- Cambiar Una Cola Por Una Pila -------------*/
int colaToPila(Tnodo**cola);

/*------- Cambiar Una Cola por Una Lista Ordenada ----------*/
int colaToLista(Tnodo**cola);

/*------- Cambiar Una Cola por Una Lista Ordenada ----------*/
int colaToListaDec(Tnodo**cola);





/* ====================== OPERACIONES CON LISTAS ========================= */


/*--------------- Insertar En Lista Ordenada ---------------*/
int insertarEnLista(Tnodo **lista,Tnodo** nodo);
int insertarEnListaDec(Tnodo **lista,Tnodo** nodo);


int sizeofList(Tnodo** lista);
